home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.4d7 source / tn3270 / settings.c < prev    next >
Text File  |  1992-04-17  |  36KB  |  1,325 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.4d7  April, 1992
  5.  *  Copyright (c) 1988, 1989, 1990, 1991, 1992 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #if !defined(USEDUMP)
  34.     #include "maclib.h"
  35.     #include "termdef.h"
  36.     #include "tn3270funcs.h"
  37.     #include "globals.h"
  38. #else
  39.     #pragma load "tn3270DumpFile"
  40. #endif
  41.  
  42. #define WRITEBUFFSIZE 256
  43.  
  44. #pragma segment 3270seg3
  45.  
  46. extern struct Point sfppoint, sfgpoint;
  47. static char dlgautoconn;
  48.  
  49. keyinfo keytab[] = {
  50.     {"host_name", 's', 255, nshostname, "Host name", 0},
  51.     {"window_title", 's', 255, nswtitle, "Window title", 0},
  52.     {"default_ptsize", 'i', 2, &ns.dfltptsize, "Default (24-by-80) point size", ptsizeproc},
  53.     {"alt_ptsize", 'i', 2, &ns.altptsize, "Alternate screen point size", ptsizeproc},
  54.     {"alt_rows", 'i', 2, &ns.altrows, "Alternate screen rows", rowproc},
  55.     {"alt_cols", 'i', 2, &ns.altcols, "Alternate screen columns", colproc},
  56.     {"custom_rows", 'i', 2, &ns.custrows, "Custom size rows", rowproc},
  57.     {"custom_cols", 'i', 2, &ns.custcols, "Custom size columns", colproc},
  58.     {"max_window_size", 'b', 1, &ns.windmax, "Always use window size for largest screen size (flag)", 0},
  59.     {"save_window_pos", 'c', 1, &ns.savewpos, "Save window position: 0 = no, 1 = yes, 2 = saved in this file", max2proc},
  60.     {"window_hloc", 'i', 2, &ns.windpth, "Window center point- horizontal position", 0},
  61.     {"window_vloc", 'i', 2, &ns.windptv, "Window center point- vertical position", 0},
  62.     {"text_creator", 'o', 4, &ns.text_creator, "Text file creator signature", 0},
  63.     {"ext_datastream", 'b', 1, &ns.ext3270, "Support extended datastreams (flag)", 0},
  64.     {"no_graphics", 'b', 1, &ns.nographics, "Don't allocate graphics bitmap (flag)", 0},
  65.     {"no_color", 'b', 1, &ns.nocolor, "Use B&W regardless of monitor setting (flag)", 0},
  66.     {"insert_reset", 'b', 1, &ns.insreset, "Attention key resets insert mode (flag)", 0},
  67.     {"imp_null", 'b', 1, &ns.impnull, "Improved nulls processing (flag)", 0},
  68.     {"replace_nulls", 'b', 1, &ns.repnull, "Change embedded blanks to nulls (flag)", 0},
  69.     {"digitpfk", 'b', 1, &ns.digitpfk, "Cmd Shift <digit> is PF (flag)", 0},
  70.     {"std_brackets", 'b', 1, &ns.std_brack, "Treat [ and ] as normal characters (flag)", 0},
  71.     {"double-click", 'i', 2, &ns.mousepf, "Double-click action", pfproc},
  72.     {"attribute_settings", 'l', 7, ns.attrmap, "Highlighting attribute settings", 0},
  73.     {"white", 'r', 3, &ns.usrwhite, "RGB values for white", 0},
  74.     {"yellow", 'r', 3, &ns.usryellow, "RGB values for yellow", 0},
  75.     {"pink", 'r', 3, &ns.usrpink, "RGB values for pink", 0},
  76.     {"turquoise", 'r', 3, &ns.usrturquoise, "RGB values for turquoise", 0},
  77.     {"green", 'r', 3, &ns.usrgreen, "RGB values for green", 0},
  78.     {"red", 'r', 3, &ns.usrred, "RGB values for red", 0},
  79.     {"blue", 'r', 3, &ns.usrblue, "RGB values for blue", 0},
  80.     {"black", 'r', 3, &ns.usrblack, "RGB values for black", 0},
  81.     {"bkgr_color", 'r', 3, &ns.usrback, "RGB values for background color", 0},
  82.     {"status_color", 'r', 3, &ns.usrstat, "RGB values status line color", 0},
  83.     {"exact_colors", 'b', 1, &ns.exactcolor, "Use exact colors (flag)", 0},
  84.     {"base_color", 'b', 1, &ns.basecolor, "Base color mode (flag)", 0},
  85.     {"swap_bw", 'b', 1, &ns.invertbw, "Swap black and white colors (flag)", 0},
  86.     {"simulate_ps", 'b', 1, &ns.simps, "Tell host programmed symbols are supported (flag)", 0},
  87.     {"time_display", 'c', 1, &ns.stat_time, "Status line time: 0 = off, 1 = 12-hr., 2 = 24-hr.", max2proc},
  88.     {"block_cursor", 'b', 1, &ns.blockcurs, "Use block cursor (flag)", 0},
  89.     {"cursor_position", 'b', 1, &ns.curpos, "Display cursor position (flag)", 0},
  90.     {"auto_open", 'b', 1, &ns.autoconn, "Open new session when settings are loaded (flag)", 0},
  91.     {"keep_window", 'b', 1, &ns.keepwindow, "Keep window after connection closes (flag)", 0},
  92.     {"beep_sound", 's', 255, nssndname, "Beep sound name", 0},
  93.     {"keyboard_mapping", 's', 255, nskybdname, "Keyboard mapping name", 0},
  94.     {"national_language", 's', 255, nsnlname, "National language name", 0},
  95.     {"conn_type", 'c', 1, &ns.setsflg, "Connection type: 0 = standalone, 1 = serial, 2 = TCP/IP", max2proc},
  96.     {"timeout", 'c', 1, &ns.timeout, "Seconds between retransmits", 0},
  97.     {"retries", 'c', 1, &ns.retries, "Number of retries", 0},
  98.     {"debug_level", 'c', 1, &ns.dblevel, "Debugging level", 0},
  99.     {0, 0, 0, 0, 0, 0} };        /* marks end of list */
  100.  
  101. unsigned char setmsg1[256];    
  102. unsigned char setmsg2[256];
  103. unsigned char setmsg3[256];
  104.  
  105. void read_settings(char initflg, cnr *cp)
  106. {
  107. Point where;
  108. FileFilterProcPtr fileFilter;
  109. DlgHookProcPtr dlgHook;
  110. short numTypes;
  111. SFTypeList typeList;
  112. SFReply reply;
  113. short appmsg, appcount, i;
  114. AppFile appinfo;
  115.  
  116. if (initflg) {            /* get files passed at launch time */
  117.     CountAppFiles(&appmsg, &appcount);
  118.     if (appcount == 0) return;
  119.     for (i=1; i <= appcount; i++) {
  120.         GetAppFiles(i, &appinfo);
  121.         if ((appmsg == 0) && (appinfo.fType == 'GFTS')) {
  122.             p2cstr(&appinfo.fName);
  123.             use_settings(&appinfo.fName, appinfo.vRefNum, cp);
  124.             }
  125.         ClrAppFiles(i);
  126.         }
  127.     }
  128. else {
  129.     where = sfgpoint;
  130.     fileFilter = 0;
  131.     dlgHook = 0;
  132.     numTypes = 1;
  133.     typeList[0] = 'GFTS';
  134.     arrowcursor();
  135.     if (newroms && (cp != 0)) {
  136.         dlgautoconn = cp->cs.autoconn;
  137.         dlgHook = (DlgHookProcPtr)sfgethook;
  138.         SFPGetFile(where, "\pObtain settings from:", fileFilter,
  139.                   numTypes, typeList, dlgHook, &reply, 4000, 0);
  140.         if (reply.good != 0) {
  141.             cp->cs.autoconn = dlgautoconn;
  142.             }
  143.         }
  144.     else {
  145.         dlgHook = 0;
  146.         SFGetFile(where, "\pObtain settings from:", fileFilter,
  147.                   numTypes, typeList, dlgHook, &reply);
  148.         }
  149.     if (reply.good == 0) return;
  150.     p2cstr(&reply.fName);
  151.     use_settings(&reply.fName, reply.vRefNum, cp);
  152.     }
  153. }
  154.  
  155. pascal short sfgethook(short MySFitem, DialogPtr theDialog)
  156. {
  157. if (MySFitem == -1) MySFitem = 24;    /* switch arguments must be >= 0 */
  158.  
  159. switch (MySFitem) {
  160.     case 11:
  161.             dlgautoconn = 1;
  162.             setit(11, theDialog, dlgautoconn > 0);
  163.             setit(12, theDialog, dlgautoconn == 0);
  164.             break;
  165.     case 12:
  166.             dlgautoconn = 0;
  167.             setit(11, theDialog, dlgautoconn > 0);
  168.             setit(12, theDialog, dlgautoconn == 0);
  169.             break;
  170.     case 24:                /* initialization */
  171.             setit(11, theDialog, dlgautoconn > 0);
  172.             setit(12, theDialog, dlgautoconn == 0);
  173.             break;
  174.     default:
  175.             break;
  176.     }
  177.  
  178. return(MySFitem);
  179. }
  180.  
  181. void use_settings(unsigned char *fname, short vnum, cnr *cp)
  182. {
  183. OSErr rc;
  184. char changed, update;
  185. char oldformat;
  186.  
  187.                                 /* start with default settings unless 
  188.                                    updating the active session            */
  189. update = 0;
  190. if (cp != 0) {
  191.     update = cp->cs.autoconn == 0;
  192.     }
  193. if (update) {
  194.     ns = cp->cs;
  195.     strcpy(nshostname, cp->cshostname);
  196.     strcpy(nswtitle, cp->cswtitle);
  197.     strcpy(nskybdname, cp->cskybdname);
  198.     strcpy(nsnlname, cp->csnlname);
  199.     strcpy(nssndname, cp->cssndname);
  200.     }
  201. else {
  202.     ns = ds;
  203.     strcpy(nshostname, dshostname);
  204.     strcpy(nswtitle, fname);            /* filename is default window title */
  205.     strcpy(nskybdname, dskybdname);
  206.     strcpy(nsnlname, dsnlname);
  207.     strcpy(nssndname, dssndname);
  208.     }
  209.  
  210. rc = get_settings(fname, vnum, &oldformat);
  211. if (rc != 0) return;
  212.  
  213.                                     /* adjust for screen size */
  214. adjfmt(&changed, &ns.windmax, &ns.dfltptsize, &ns.altptsize,
  215.        &ns.altrows, &ns.altcols);
  216. if (changed) {
  217.     note_err(fmtalrt, cp);
  218.     }
  219.  
  220. if (update) {                        /* update current session */
  221.     cp->fsoldformat = oldformat;
  222.     settings_update(&ns, nswtitle, nskybdname, nsnlname, nssndname, cp);
  223.     }
  224. else {
  225.     newlogin(0, 1, fname, vnum, oldformat);
  226.     }
  227. }
  228.  
  229. short get_settings(unsigned char * fname, short vnum,
  230.                    unsigned char *oldformat)
  231. {
  232.                             /* state table for reading definition file */
  233. static unsigned char statetab[] =
  234. /*                                0        1        2        3        4        5        6        7    */
  235. /*                               space   char     '='     '#'       '"'       CR     other    EOF    */
  236. /* 0: before name field    */ {    0,        2,       10,        1,       10,        0,       10,        0,
  237. /* 1: comment line        */        1,        1,        1,        1,        1,        0,        1,        0,
  238. /* 2: reading name        */        3,        2,        4,       10,       10,       10,       10,       10,
  239. /* 3: between name and =*/        3,       10,        4,       10,       10,       10,       10,       10,
  240. /* 4: between = and val    */        4,        5,       10,       10,        6,       10,       10,       10,
  241. /* 5: reading value        */        8,        5,       10,        9,       10,        0,       10,        0,
  242. /* 6: reading quote val */        6,        6,        6,        6,        7,       10,       10,       10,
  243. /* 7: quote in quote val*/        8,       10,       10,        9,        6,        0,       10,        0,
  244. /* 8: after value        */        8,       10,       10,        9,       10,        0,       10,        0,
  245. /* 9: end comment        */        9,        9,        9,        9,        9,        0,        9,        0 };
  246. /*10: error                */
  247.  
  248. short fnum;
  249. OSErr rc;
  250. long filesize, l, readcount, lastoffset;
  251. unsigned char * filedata;
  252. unsigned char * nameptr;
  253. short oldstate, state, charindex;
  254. short linenum, namelen, valuelen;
  255. short msg3len;
  256. unsigned char *valuestr;
  257. OSErr value_err;
  258. int t[7];
  259. short orig_windpth, orig_windptv;
  260.  
  261. nameptr =  0;                /* just to avoid warning messages */
  262. namelen = valuelen = 0;
  263. valuestr = 0;
  264. (*oldformat) = 0;
  265.  
  266.                     /* prepare first part of error messages */
  267. sprintf(setmsg1, "Error reading settings file \"%s\":", fname);
  268.                     /* null file line text */
  269. setmsg3[0] = 0;
  270.                     /* read definition file into buffer */
  271. rc = fsrdopen(fname, vnum, &fnum);
  272. if (rc != 0) {
  273.     sprintf(setmsg2, "Error %d opening file", rc);
  274.     seterr();
  275.     return(rc);
  276.     }
  277. rc = GetEOF(fnum, &filesize);    /* get file size */
  278. if (rc != 0) {
  279.     FSClose(fnum);
  280.     sprintf(setmsg2, "Error %d getting file size", rc);
  281.     seterr();
  282.     return(rc);
  283.     }
  284. filedata = (unsigned char *)NewPtr(filesize+1);    /* allocate buffer */
  285.                             /* extra byte for null termination */
  286. if (filedata == 0L) {
  287.     FSClose(fnum);
  288.     sprintf(setmsg2, "Not enough storage (%ld bytes) for file", filesize);
  289.     seterr();
  290.     return(rc);
  291.     }
  292. readcount = filesize;            /* read file data */
  293. rc = FSRead(fnum, &readcount, filedata);
  294. FSClose(fnum);                    /* close file */
  295. if ((rc != 0) || (readcount != filesize)) {
  296.     DisposPtr(filedata);
  297.     if (rc == 0) rc = 4;
  298.     sprintf(setmsg2, "Error %d reading file contents", rc);
  299.     seterr();
  300.     return(rc);
  301.     }
  302. filedata[filesize] = 0;            /* null-terminate */
  303.  
  304.                     /* check for the old file format */
  305.                     /* try to read the attribute bytes */
  306. rc = sscanf(filedata, "%x %x %x %x %x %x %x",
  307.                 t, t+1, t+2, t+3, t+4, t+5, t+6);
  308. if (rc == 7) {            /* must be old format */
  309.     DisposPtr(filedata);
  310.     (*oldformat) = 1;
  311.     return(read_old_format(fname, vnum));
  312.     }
  313.  
  314. orig_windpth = ns.windpth;    /* need to restore these if not saved in file */
  315. orig_windptv = ns.windptv;
  316. state = 0;
  317. linenum = 1;
  318. setmsg3[0] = '"';
  319. msg3len = 1;
  320. lastoffset = 0;
  321. value_err = 0;
  322. for (l=0; l <= filesize; l++) {
  323.     if (l < filesize) {
  324.         charindex = chrval(filedata[l]);
  325.         lastoffset = l;
  326.         }
  327.     else charindex = 7;        /* EOF */
  328.     if ((charindex < 7) && (msg3len < 254) && (charindex != 5))
  329.         setmsg3[msg3len++] = filedata[l];
  330.     oldstate = state;
  331.     state = statetab[oldstate*8 + charindex]; 
  332.     if (state == 10) break;
  333.     if ((oldstate >= 5) && (state == 0)) {
  334.         if (valuelen == 0) {    /* null strings can be parsed but are not allowed */
  335.             state = 10;
  336.             break;
  337.             }
  338.         valuestr[valuelen] = 0;
  339.         rc = setval(nameptr, namelen, valuestr, valuelen);
  340.         if (rc != 0) {
  341.             value_err = rc;
  342.             state = 10;
  343.             break;
  344.             }
  345.         }
  346.     if (charindex == 5) {
  347.         linenum++;
  348.         setmsg3[0] = '"';
  349.         msg3len = 1;
  350.         }
  351.     if (charindex < 4) {
  352.         switch(state) {
  353.                 case 6:
  354.                         if (oldstate >= 6) {
  355.                             if (valuelen == 0) {
  356.                                 valuestr = filedata+l;
  357.                                 }
  358.                             valuestr[valuelen++] = filedata[l];
  359.                             }
  360.                         break;
  361.                 default:    
  362.                         break;
  363.                 }
  364.         }
  365.     if (charindex == 1) {
  366.         switch(state) {
  367.                 case 2:
  368.                         if (oldstate == 2) {
  369.                             namelen++;
  370.                             }
  371.                         else {
  372.                             nameptr = filedata+l;
  373.                             namelen = 1;
  374.                             }
  375.                         break;
  376.                 case 5:
  377.                         if (oldstate == 5) {
  378.                             valuelen++;
  379.                             }
  380.                         else {
  381.                             valuestr = filedata+l;
  382.                             valuelen = 1;
  383.                             }
  384.                         break;
  385.                 default:
  386.                         break;
  387.                 }
  388.         }
  389.     if (charindex == 4) {
  390.         switch(state) {
  391.                 case 6:
  392.                         if (oldstate == 4) {
  393.                             valuelen = 0;
  394.                             }
  395.                         if (oldstate == 7) {
  396.                             if (valuelen == 0) {
  397.                                 valuestr = filedata+l-1;
  398.                                 }
  399.                             valuestr[valuelen++] = '"';
  400.                             }
  401.                         break;
  402.                 default:
  403.                         break;
  404.                 }
  405.         }
  406.     }
  407. DisposPtr(filedata);
  408.  
  409. if (state == 10) {        /* error state */
  410.     if (value_err > 0) {
  411.         sprintf(setmsg2, "Value error %d on line %d:", value_err, linenum);
  412.         }
  413.     else {
  414.         sprintf(setmsg2, "Syntax error at position %ld on line %d:",
  415.                 lastoffset, linenum);
  416.         }
  417.     setmsg3[msg3len++] = '"';
  418.     setmsg3[msg3len] = 0;
  419.     seterr();
  420.     setmsg3[0] = 0;
  421.     return(10);
  422.     }
  423.  
  424. if (ns.savewpos != 2) {                /* restore window position if file values */
  425.     ns.windpth = orig_windpth;            /* are not valid */
  426.     ns.windptv = orig_windptv;
  427.     }
  428.  
  429. return(0);
  430. }
  431.  
  432. short chrval(unsigned char chr)
  433. {
  434. switch(chr) {
  435.     case '=':
  436.             return(2);
  437.             break;
  438.     case '#':
  439.             return(3);
  440.             break;
  441.     case '"':
  442.             return(4);
  443.             break;
  444.     case 0x0d:
  445.             return(5);
  446.             break;
  447.     default:
  448.             if (chr > 127) return(1);
  449.             if (isspace(chr)) return(0);
  450.             else if (iscntrl(chr)) return(6);
  451.                     else return(1);
  452.             break;
  453.     }
  454. }
  455.  
  456. short setval(unsigned char * nameptr,
  457.              short namelen,
  458.              unsigned char * valueptr,
  459.              short valuelen)
  460. {
  461. short i;
  462. unsigned short u;
  463. keyinfo * k;
  464. unsigned char namesave;
  465. short rc;
  466. unsigned short r[10];
  467. short (*procptr)(void *);
  468.  
  469. for (i=0; i < namelen; i++)
  470.     nameptr[i] = tolower(nameptr[i]);
  471. namesave = nameptr[namelen];
  472. nameptr[namelen] = 0;
  473. valueptr[valuelen] = 0;
  474. k = keytab;
  475. while (k->size > 0) {
  476.     if (strcmp(nameptr, k->name) == 0) break;
  477.     k++;
  478.     }
  479. nameptr[namelen] = namesave;
  480. if (k->size == 0) return(1);
  481. switch(k->type) {
  482.     case 'a':            /* string of arbitrary length */
  483.         if (k->procptr != 0) {
  484.             procptr = k->procptr;
  485.             rc = (*procptr)(&i);
  486.             if (rc != 0) return(rc);            
  487.             }
  488.         rc = alloc_copy((unsigned char **)(k->valptr), valueptr, valuelen);
  489.         if (rc != 0) return(14);
  490.         break;
  491.     case 'b':            /* binary flag */
  492.         for (i=0; i < valuelen; i++)
  493.             if (!isdigit(valueptr[i])) return(3);
  494.         i = atoi(valueptr);
  495.         if ((i < 0) || (i > 1)) return(4);
  496.         if (k->procptr != 0) {
  497.             procptr = k->procptr;
  498.             rc = (*procptr)(&i);
  499.             if (rc != 0) return(rc);            
  500.             }
  501.         *((unsigned char *)k->valptr) = i;
  502.         break;
  503.     case 'c':            /* unsigned char (decimal) */
  504.         for (i=0; i < valuelen; i++)
  505.             if (!isdigit(valueptr[i])) return(3);
  506.         i = atoi(valueptr);
  507.         if ((i < 0) || (i > 255)) return(4);
  508.         if (k->procptr != 0) {
  509.             procptr = k->procptr;
  510.             rc = (*procptr)(&i);
  511.             if (rc != 0) return(rc);            
  512.             }
  513.         *((unsigned char *)k->valptr) = i;
  514.         break;
  515.     case 'i':            /* integer */
  516.         for (i=0; i < valuelen; i++) {
  517.             if (i == 0) {
  518.                 if (valueptr[0] == '-') continue;
  519.                 }
  520.             if (!isdigit(valueptr[i])) return(5);
  521.             }
  522.         i = atoi(valueptr);
  523.         if (k->procptr != 0) {
  524.             procptr = k->procptr;
  525.             rc = (*procptr)(&i);
  526.             if (rc != 0) return(rc);            
  527.             }
  528.         *((short *)(k->valptr)) = i;
  529.         break;
  530.     case 'l':            /* list of hex values (space separated) */
  531.         if ((k->size < 1) || (k->size > 10)) return(7);
  532.         for (i=0; i < valuelen; i++)
  533.             if (!(isxdigit(valueptr[i]) || isspace(valueptr[i]))) return(8);
  534.         rc = sscanf(valueptr, "%hx %hx %hx %hx %hx %hx %hx %hx %hx %hx",
  535.                     r, r+1, r+2, r+3, r+4, r+5, r+6, r+7, r+8, r+9);
  536.         if (rc != k->size) return(9);
  537.         if (k->procptr != 0) {
  538.             procptr = k->procptr;
  539.             rc = (*procptr)(&i);
  540.             if (rc != 0) return(rc);            
  541.             }
  542.         for (i=0; i < k->size; i++) {
  543.             ((unsigned char *)(k->valptr))[i] = r[i];
  544.             }
  545.         break;
  546.     case 'o':            /* OSType */
  547.         if (valuelen != 4) return(10);
  548.         if (k->procptr != 0) {
  549.             procptr = k->procptr;
  550.             rc = (*procptr)(&i);
  551.             if (rc != 0) return(rc);            
  552.             }
  553.         memcpy(k->valptr, valueptr, 4);
  554.         break;
  555.     case 'r':            /* RGB color */
  556.         if ((k->size < 1) || (k->size > 10)) return(7);
  557.         for (i=0; i < valuelen; i++)
  558.             if (!(isdigit(valueptr[i]) || isspace(valueptr[i]))) return(8);
  559.         rc = sscanf(valueptr, "%hd %hd %hd %hd %hd %hd %hd %hd %hd %hd",
  560.                     r, r+1, r+2, r+3, r+4, r+5, r+6, r+7, r+8, r+9);
  561.         if (rc != k->size) return(9);
  562.         if (k->procptr != 0) {
  563.             procptr = k->procptr;
  564.             rc = (*procptr)(&i);
  565.             if (rc != 0) return(rc);            
  566.             }
  567.         for (i=0; i < k->size; i++) {
  568.             ((unsigned short *)(k->valptr))[i] = r[i];
  569.             }
  570.         break;
  571.     case 's':            /* string */
  572.         if (valuelen > k->size) return(6);
  573.         if (k->procptr != 0) {
  574.             procptr = k->procptr;
  575.             rc = (*procptr)(&i);
  576.             if (rc != 0) return(rc);            
  577.             }
  578.         memset(k->valptr, 0, k->size+1);
  579.         memcpy(k->valptr, valueptr, valuelen);
  580.         break;
  581.     case 'u':            /* unsigned integer */
  582.         for (i=0; i < valuelen; i++)
  583.             if (!isdigit(valueptr[i])) return(5);
  584.         u = atoi(valueptr);
  585.         if (k->procptr != 0) {
  586.             procptr = k->procptr;
  587.             rc = (*procptr)(&u);
  588.             if (rc != 0) return(rc);            
  589.             }
  590.         *((unsigned short *)(k->valptr)) = u;
  591.         break;
  592.     case 'x':            /* unsigned char (hex) */
  593.         for (i=0; i < valuelen; i++)
  594.             if (!isxdigit(valueptr[i])) return(11);
  595.         if (sscanf(valueptr, "%hx", &i) != 1) return(12);
  596.         if ((i < 0) || (i > 255)) return(13);
  597.         if (k->procptr != 0) {
  598.             procptr = k->procptr;
  599.             rc = (*procptr)(&i);
  600.             if (rc != 0) return(rc);            
  601.             }
  602.         *((unsigned char *)k->valptr) = i;
  603.         break;
  604.     default:
  605.         return(2);
  606.         break;
  607.     }
  608. return(0);
  609. }
  610.  
  611. OSErr alloc_copy(unsigned char **dest,
  612.                  unsigned char *source,
  613.                  short len)
  614. {
  615. Size currentsize;
  616. Ptr newvalptr;
  617.  
  618. (*dest)[0] = 0;
  619. currentsize = GetPtrSize(*dest);
  620. if (currentsize < (len+1)) {
  621.     newvalptr = NewPtr((Size)(len+1));
  622.     if (newvalptr == 0) {
  623.         return(1);
  624.         }
  625.     else {
  626.         DisposPtr(*dest);
  627.         *dest = newvalptr;
  628.         currentsize = len+1;
  629.         }
  630.     }
  631. memset(*dest, 0, currentsize);
  632. memcpy(*dest, source, len);
  633. return(0);
  634. }
  635.  
  636. short ptsizeproc(void *resultptr)
  637. {
  638. char num;
  639.  
  640. num = *((short *)resultptr);
  641. if ((num == 9) || (num == 12)) return(0);
  642. return(1);
  643. }
  644.  
  645. short rowproc(void *resultptr)
  646. {
  647. char num;
  648.  
  649. num = *((short *)resultptr);
  650. if (num >= 24) return(0);
  651. return(1);
  652. }
  653.  
  654. short colproc(void *resultptr)
  655. {
  656. char num;
  657.  
  658. num = *((short *)resultptr);
  659. if (num >= 80) return(0);
  660. return(1);
  661. }
  662.  
  663. short max2proc(void *resultptr)
  664. {
  665. char num;
  666.  
  667. num = *((short *)resultptr);
  668. if ((num >= 0) && (num <= 2)) return(0);
  669. return(1);
  670. }
  671.  
  672. short pfproc(void *resultptr)
  673. {
  674. short num;
  675.  
  676. num = *((short *)resultptr);
  677. if ((num >= 1) && (num <= 32)) return(0);
  678. return(1);
  679. }
  680.  
  681. OSErr read_old_format(char *fname, short vnum)
  682. {
  683. short fnum;
  684. OSErr rc;
  685. long count;
  686. int t[70];
  687. short colors[27];
  688. unsigned char buffer[800];
  689. unsigned char tstring[256];
  690. unsigned char tstring2[256];
  691. unsigned char tstring3[256];
  692. unsigned char tstring4[256];
  693. unsigned char tstring5[256];
  694. short tlen, tnum;
  695. char scan_ok;
  696. short i;
  697. short tcount;
  698. char tsave;
  699. unsigned char * tptr, * tend;
  700.  
  701. rc = fsrdopen(fname, vnum, &fnum);
  702. if (rc != 0) {
  703.     stoperr(rsetalrt, 0);
  704.     return(rc);
  705.     }
  706.  
  707. count = 798;
  708. rc = FSRead(fnum, &count, buffer);
  709. FSClose(fnum);
  710. if ((rc != 0) && (rc != eofErr)) {
  711.     stoperr(rsetalrt, 0);
  712.     return(rc);
  713.     }
  714. buffer[count] = 0;    /* terminate C string */
  715. tptr = buffer;        /* initialize token pointer */
  716. tcount = 0;            /* initialize token count */
  717. while (1) {
  718.     while (isspace(*tptr)) tptr++;
  719.     if ((*tptr) == 0) break;
  720.     tend = tptr;
  721.     while ((!isspace(*tend)) && ((*tend) != 0)) tend++;
  722.     tsave = (*tend);
  723.     (*tend) = 0;
  724.     if (tcount < 7) rc = sscanf(tptr, "%x", t+tcount);
  725.     else if (tcount == 7) rc = sscanf(tptr, "%d", t+tcount);
  726.     else if (tcount == 8) rc = sscanf(tptr, "%s", tstring);
  727.     else if (tcount < 18) rc = sscanf(tptr, "%d", t+tcount-1);
  728.     else if (tcount < 45) rc = sscanf(tptr, "%x", t+tcount-1);
  729.     else if (tcount < 47) rc = sscanf(tptr, "%d", t+tcount-1);
  730.     else if (tcount < 57) rc = sscanf(tptr, "%x", t+tcount-1);
  731.     else if (tcount == 57) rc = sscanf(tptr, "%s", tstring2);
  732.     else if (tcount < 59) rc = sscanf(tptr, "%x", t+tcount-2);
  733.     else if (tcount == 59) rc = sscanf(tptr, "%s", tstring3);
  734.     else if (tcount < 64) rc = sscanf(tptr, "%d", t+tcount-3);
  735.     else if (tcount == 64) rc = sscanf(tptr, "%s", tstring4);
  736.     else if (tcount < 71) rc = sscanf(tptr, "%x", t+tcount-4);
  737.     else if (tcount == 71) rc = sscanf(tptr, "%s", tstring5);
  738.     else if (tcount < 75) rc = sscanf(tptr, "%x", t+tcount-5);
  739.     if (rc != 1) break;
  740.     tcount++;
  741.     if (tcount == 75) break;
  742.     (*tend) = tsave;
  743.     tptr = tend;
  744.     }
  745.                         /* check validity of data */
  746. scan_ok = 0;
  747. if ((tcount == 16) || (tcount >= 45)) {
  748.     scan_ok = 1;
  749.                                         /* host name */
  750.     tlen = strlen(tstring);
  751.     if ((tlen > 255) || (tlen == 0)) scan_ok = 0;
  752.     if (strcmp(tstring, "''") == 0) tstring[0] = '\0';
  753.                                         /* t array */
  754.                         /* tnum = number of array elements used */
  755.     tnum = tcount;
  756.                         /* adjust for string settings */
  757.     if (tcount > 8) tnum--;
  758.     if (tcount > 57) tnum--;
  759.     if (tcount > 59) tnum--;
  760.     if (tcount > 64) tnum--;
  761.     if (tcount > 71) tnum--;
  762.     for (i = 7; i < tnum; i++) {
  763.         if ((i >= 17) && (i <= 43)) continue;    /* skip colors */
  764.         if ((i >= 50) && (i <= 52)) continue;    /* status line color */
  765.         switch(i) {
  766.             case 8:                        /* connection type */
  767.             case 47:                    /* status line time */
  768.                         if ((t[i] < 0) || (t[i] > 2)) scan_ok = 0;
  769.                         break;
  770.             case 14:                    /* double-click */
  771.                         if ((t[i] < 1) || (t[i] > 36)) scan_ok = 0;
  772.                         break;
  773.             case 44:                    /* alternate rows */
  774.             case 59:                    /* custom rows */
  775.                         if (t[i] < 24) scan_ok = 0;
  776.                         break;
  777.             case 58:                    /* alternate columns */
  778.             case 60:                    /* custom columns */
  779.                         if (t[i] < 80) scan_ok = 0;
  780.                         break;
  781.             case 45:                    /* alternate font size*/
  782.             case 57:                    /* default font size */
  783.                         if ((t[i] != 9) && (t[i] != 12)) scan_ok = 0;
  784.                         break;
  785.             case 7:                        /* debug level */
  786.             case 9:                        /* timeout */
  787.             case 10:                    /* retries */
  788.             case 62:                    /* window h pos */
  789.             case 63:                    /* window v pos */
  790.             case 65:                    /* text creator */
  791.                         break;
  792.             case 61:                    /* savewpos */
  793.                         if ((t[i] < 0) || (t[i] > 2)) scan_ok = 0;
  794.                         break;
  795.             default:                    /* boolean flags */
  796.                         if ((t[i] != 0) && (t[i] != 1)) scan_ok = 0;
  797.                          break;
  798.             }
  799.         }
  800.     if (tcount >= 58) {
  801.         tlen = strlen(tstring2);                /* keymap name */
  802.         if ((tlen > 255) || (tlen == 0)) scan_ok = 0;
  803.         }
  804.     if (tcount >= 60) {
  805.         tlen = strlen(tstring3);                /* national language */
  806.         if ((tlen > 255) || (tlen == 0)) scan_ok = 0;
  807.         }
  808.     if (tcount >= 65) {
  809.         tlen = strlen(tstring4);                /* 'snd ' name */
  810.         if ((tlen > 255) || (tlen == 0)) scan_ok = 0;
  811.         }
  812.     if (tcount >= 72) {
  813.         tlen = strlen(tstring5);                /* 'snd ' name */
  814.         if ((tlen > 255) || (tlen == 0)) scan_ok = 0;
  815.         }
  816.                             /*  check window position present if saved */
  817.     if (tcount >= 66) {
  818.         if ((t[61] == 2) && (tcount < 68)) scan_ok = 0;
  819.         }
  820.     }
  821. if (scan_ok == 0) {
  822.     stoperr(ssetalrt, 0);
  823.     return(1);
  824.     }
  825.  
  826. for (i=0; i < 7; i++) ns.attrmap[i] = t[i];
  827. ns.dblevel = t[7];
  828. ns.setsflg = t[8];
  829. strcpy(nshostname, tstring);
  830. ns.timeout = t[9];
  831. ns.retries = t[10];
  832. ns.insreset = t[11];
  833. ns.impnull = t[12];
  834. ns.digitpfk = t[13];
  835. ns.mousepf = t[14];
  836. if (tcount >= 45) {
  837.     ns.basecolor = t[15];
  838.     ns.exactcolor = t[16];
  839.     for (i=0; i < 27; i++) colors[i] = t[i+17];
  840.     memcpy(&ns.usrwhite, colors, 54);
  841.     }
  842. if (tcount >= 48) ns.invertbw = t[46];
  843. if (tcount >= 49) ns.stat_time = t[47];
  844. if (tcount >= 50) ns.curpos = t[48];
  845. if (tcount >= 51) ns.blockcurs = t[49];
  846. if (tcount >= 54) {
  847.     ns.usrstat.red = t[50];
  848.     ns.usrstat.green = t[51];
  849.     ns.usrstat.blue = t[52];
  850.     }
  851. if (tcount >= 55) ns.ext3270 = t[53];
  852. if (tcount >= 56) ns.std_brack = t[54];
  853. if (tcount >= 58) copyrdstr(nskybdname, tstring2);
  854. if (tcount >= 59) ns.repnull = t[56];
  855. if (tcount >= 60) copyrdstr(nsnlname, tstring3);
  856. /* handle screen format settings */
  857. if (tcount >= 61) {                        /* new format */
  858.     ns.altrows = t[44];
  859.     ns.altptsize = t[45];
  860.     ns.windmax = t[55];
  861.     ns.dfltptsize = t[57];
  862.     if (tcount >= 62) ns.altcols = t[58];
  863.     if (tcount >= 63) ns.custrows = t[59];
  864.     if (tcount >= 64) ns.custcols = t[60];
  865.     }
  866. else {                                    /* old format */
  867.     if (tcount >= 46) ns.altrows = t[44];
  868.     if (tcount >= 47) 
  869.         ns.altptsize = ns.dfltptsize = t[45];
  870.     if (tcount >= 57) ns.windmax = t[55];
  871.     ns.altcols = 80;
  872.     }
  873. if (tcount >= 65) copyrdstr(nssndname, tstring4);
  874. /* handle window position settings */
  875. if (tcount >= 66) {
  876.     ns.savewpos = t[61];        /* changed to (t[61] > 0) by caller */
  877.     if (t[61] == 2) {
  878.         ns.windpth = t[62];
  879.         ns.windptv = t[63];
  880.         }
  881.     }
  882. if (tcount >= 69) ns.autoconn = t[64];
  883. if (tcount >= 70) ns.text_creator = t[65];
  884. if (tcount >= 71) ns.simps = t[66];
  885. if (tcount >= 72) copyrdstr(nswtitle, tstring5);
  886. if (tcount >= 73) ns.keepwindow = t[67];
  887. if (tcount >= 74) ns.nographics = t[68];
  888. if (tcount >= 75) ns.nocolor = t[69];
  889. return(0);
  890. }
  891.  
  892. void copyrdstr(unsigned char *dest, unsigned char *source) 
  893. {            
  894.             /* copy string, converting underscores to blanks */
  895. register short i, j, len;
  896. register char usflag;
  897.  
  898. len = strlen(source);
  899. j = 0;
  900. usflag = 0;
  901. for (i=0; i < len; i++) {
  902.     if (source[i] == '_') {
  903.         if (usflag) {
  904.             dest[j++] = '_';
  905.             usflag = 0;
  906.             }
  907.         else {
  908.             usflag = 1;
  909.             }
  910.         }
  911.     else {
  912.         if (usflag) {
  913.             dest[j++] = ' ';
  914.             usflag = 0;
  915.             if (j == 255) break;
  916.             dest[j++] = source[i];
  917.             }
  918.         else {
  919.             dest[j++] = source[i];
  920.             }
  921.         }
  922.     if (j == 255) break;
  923.     }
  924. if (usflag && (j < 255)) {
  925.     dest[j++] = ' ';
  926.     }
  927. dest[j] = 0;
  928. }
  929.  
  930. void settings_update(settings_list *sl,
  931.                      unsigned char *wtitle,
  932.                      unsigned char *kybdname,
  933.                      unsigned char *nlname,
  934.                      unsigned char *sndname, cnr* cp)
  935. {
  936. static unsigned char * ScrDmpEnb = (unsigned char *)0x2f8;
  937. char setsflg;
  938. short altrows, altcols;
  939. OSErr rc;
  940. Handle temph, temph2;
  941. unsigned char tstring[256];
  942. short rid;
  943. ResType rtype;
  944.                                         /* save settings that we don't want
  945.                                            changed by structure assignment    */
  946. setsflg = cp->cs.setsflg;                    /* connection type */
  947. altrows = cp->cs.altrows;                    /* alternate screen size */
  948. altcols = cp->cs.altcols;
  949.                                         /* copy settings */
  950. cp->cs = cp->fs = *sl;
  951. strcpy(cp->fswtitle, wtitle);
  952. strcpy(cp->cswtitle, wtitle);
  953. strcpy(cp->fskybdname, kybdname);        /* "cs" values for these are changed */
  954. strcpy(cp->fsnlname, nlname);            /* when resources are checked */
  955. strcpy(cp->fssndname, sndname);
  956.  
  957. cp->cs.setsflg = setsflg;                /* restore connection type */
  958. cp->serflg = (cp->cs.setsflg == 1);
  959. cp->tcpflg = (cp->cs.setsflg == 2);
  960.  
  961. if (cp->myWindow != 0) {                /* command-shift enable */
  962.     if (cp->cs.digitpfk) (*ScrDmpEnb) = 0;
  963.     else (*ScrDmpEnb) = ScrDmpSav;
  964.     }
  965.                                         /* set new colors */
  966. if (colormac && (!cp->cs.nocolor) && (cp->myWindow != 0)) {
  967.     fixcolors(cp->myPalette, cp);
  968.     ActivatePalette(cp->myWindow);
  969.     updCTab(cp);
  970.     newbackcolor(cp);
  971.     }
  972.                                         /* handle window position */
  973. cp->cs.savewpos = cp->fs.savewpos = (sl->savewpos > 0);
  974. if (sl->savewpos == 2) cp->wposok = 1;
  975.                                         /* check for new screen size */
  976. if ((cp->cs.altcols != altcols) ||            /* size changed */
  977.     (cp->cs.altrows != altrows)) {
  978.     cp->cs.altcols = altcols;                /* restore size */
  979.     cp->cs.altrows = altrows;
  980.     note_err(windfmtalrt, cp);                /* new size warning */
  981.     }
  982. else if (cp->myWindow != 0) {                /* change active session size */
  983.     newmode(cp->cur_mode, 0, cp);
  984.     }
  985.                                         /* new cursor shape */
  986. if (cp->myWindow != 0) newcur(cp);
  987.  
  988. cp->fixbracket =                        /* flag for square brackets */
  989.         cp->cs.std_brack && (!cp->aplmode) && (cp->stdfont != ALAFONT);
  990.  
  991.                                     /* update keyboard mapping */
  992. c2pstr(cp->fskybdname);
  993. temph = GetNamedResource('GFKB', cp->fskybdname);
  994. p2cstr(cp->fskybdname);
  995. if (temph == 0L) {
  996.     stoperr(kbsetalrt, cp);
  997.     }
  998. else {
  999.     cp->kb_handle = temph;
  1000.     GetResInfo(cp->kb_handle, &rid, &rtype, tstring);
  1001.     p2cstr(tstring);
  1002.     strcpy(cp->fskybdname, tstring);
  1003.     strcpy(cp->cskybdname, tstring);
  1004.     }
  1005.                                     /* update national language setting */
  1006.                                         /* check for default */
  1007. GetItem(nlMenu, 1, tstring);
  1008. p2cstr(tstring);
  1009. if (strcmp(tstring, cp->fsnlname) == 0) {
  1010.     strcpy(cp->csnlname, tstring);
  1011.     cp->nl_handle = 0;
  1012.     newstdfont(NORMALFONT, cp);
  1013.     cp->plainala = 0;
  1014.     }
  1015.                                         /* check resource */
  1016. else {
  1017.     c2pstr(cp->fsnlname);
  1018.     temph = GetNamedResource('GFNL', cp->fsnlname);
  1019.     p2cstr(cp->fsnlname);
  1020.     if (temph == 0L) {
  1021.         stoperr(nlsetalrt, cp);
  1022.         }
  1023.     else {
  1024.         GetResInfo(temph, &rid, &rtype, tstring);
  1025.         p2cstr(tstring);
  1026.         strcpy(cp->fsnlname, tstring);
  1027.         strcpy(cp->csnlname, tstring);
  1028.         if (GetHandleSize(temph) == 1) {
  1029.             cp->nl_handle = 0;
  1030.             newstdfont(**temph, cp);
  1031.             cp->plainala = 0;
  1032.             }
  1033.         else if (GetHandleSize(temph) == 3) {
  1034.             cp->nl_handle = 0;
  1035.             newstdfont(**temph, cp);
  1036.             cp->plainala = ((*temph)[1] & 0x80) == 0x80;
  1037.               }
  1038.         else {
  1039.             cp->nl_handle = temph;
  1040.             defxtab(cp->nl_handle, cp->nltab);
  1041.             newstdfont(NORMALFONT, cp);
  1042.             cp->plainala = 0;
  1043.             }
  1044.         }
  1045.     }
  1046.                                     /* get non-purgeable copy of our sound resource */
  1047. if (strcmp(cp->fssndname, dssndname) == 0) {
  1048.     if (sndactive) {
  1049.         SndDisposeChannel(scp, true);
  1050.         sndactive = 0;
  1051.         }
  1052.     if (cp->sndhandle != 0) DisposHandle(cp->sndhandle);
  1053.     cp->sndhandle = 0;
  1054.     strcpy(cp->cssndname, cp->fssndname);
  1055.     }
  1056. else {
  1057.     temph = temph2 = getsndresource(cp->fssndname);
  1058.     if (temph == 0L) {
  1059.         stoperr(sdsetalrt, cp);
  1060.         }
  1061.     else {
  1062.         rc = HandToHand(&temph2);
  1063.         if (rc != noErr) {
  1064.             ReleaseResource(temph);
  1065.             stoperr(sdmemalrt, cp);
  1066.             }
  1067.         else {
  1068.             getsndinfo(temph, &rid, &rtype, tstring);
  1069.             ReleaseResource(temph);
  1070.             if (sndactive) {
  1071.                 SndDisposeChannel(scp, true);
  1072.                 sndactive = 0;
  1073.                 }
  1074.             if (cp->sndhandle != 0) DisposHandle(cp->sndhandle);
  1075.             cp->sndhandle = temph2;
  1076.             strcpy(cp->fssndname, tstring);
  1077.             strcpy(cp->cssndname, tstring);
  1078.             }
  1079.         }
  1080.     }
  1081.  
  1082. if (cp->myWindow == 0) return;
  1083. justGrowIcon(0, cp);
  1084. invldscr(cp);
  1085. cp->cs.stat_time += 8;        /* force time to be re-drawn */
  1086. newstat(cp);
  1087. newinvbw(cp);
  1088. /* note: window title is intentionally not updated */
  1089. }
  1090.  
  1091. void write_settings(cnr *cp)
  1092. {
  1093. Point where;
  1094. DlgHookProcPtr dlgHook;
  1095. SFReply reply;
  1096. OSErr rc;
  1097. short fnum, i, j, m;
  1098. short savewpos;
  1099. keyinfo * k;
  1100. char writeok;
  1101. unsigned char s[WRITEBUFFSIZE];
  1102. unsigned char crtemp[5];
  1103. unsigned char *strval;
  1104. unsigned char c;
  1105. long count;
  1106.  
  1107. where = sfppoint;
  1108. dlgHook = 0;
  1109. arrowcursor();
  1110. c2pstr(cp->s_fName);
  1111. SFPutFile(where, "\pSave settings as:",
  1112.           cp->s_fName, dlgHook, &reply);
  1113. p2cstr(cp->s_fName);
  1114. if (reply.good == 0) return;
  1115. p2cstr(&reply.fName);
  1116. memcpy(cp->s_fName, &reply.fName, 64);        /* save filename */
  1117. c2pstr(&reply.fName);
  1118. rc = FSDelete(&reply.fName, reply.vRefNum);    /* delete existing file */
  1119. if ((rc != 0) && (rc != -43)) {        /* file not found is ok */
  1120.     stoperr(wsetalrt, cp);
  1121.     return;
  1122.     }
  1123. rc = Create(&reply.fName, reply.vRefNum, 'GFTM', 'GFTS');
  1124. if (rc != 0) {
  1125.     stoperr(wsetalrt, cp);
  1126.     return;
  1127.     }
  1128. rc = FSOpen(&reply.fName, reply.vRefNum, &fnum);
  1129. if (rc != 0) {
  1130.     stoperr(wsetalrt, cp);
  1131.     return;
  1132.     }
  1133.                         /* update window position settings */
  1134. updwindpos(cp);
  1135. savewpos = cp->cs.savewpos;
  1136. if (savewpos && cp->wposok) savewpos = 2;
  1137.  
  1138.                         /* save current values as file values */
  1139. memcpy(cp->fshostname, cp->cshostname, 256);
  1140. memcpy(cp->fskybdname, cp->cskybdname, 256);
  1141. memcpy(cp->fsnlname, cp->csnlname, 256);
  1142. memcpy(cp->fssndname, cp->cssndname, 256);
  1143. memcpy(cp->fswtitle, cp->cswtitle, 256);
  1144. cp->fs = cp->cs;
  1145. cp->fsoldformat = 0;        /* file settings will be new format */
  1146.  
  1147.                         /* also copy to "ns" variables for writing */
  1148. memcpy(nshostname, cp->cshostname, 256);
  1149. memcpy(nskybdname, cp->cskybdname, 256);
  1150. memcpy(nsnlname, cp->csnlname, 256);
  1151. memcpy(nssndname, cp->cssndname, 256);
  1152. memcpy(nswtitle, cp->cswtitle, 256);
  1153. ns = cp->cs;
  1154. ns.savewpos = savewpos;
  1155.  
  1156.                         /* write each value */
  1157. k = keytab;
  1158. writeok = 1;
  1159. while (k->size != 0) {
  1160.     s[0] = 0;
  1161.     switch (k->type) {
  1162.         case 'b':
  1163.             sprintf(s, "%s=%d \t#%s\015", k->name,
  1164.                 *((unsigned char *)k->valptr), k->description);
  1165.             break;
  1166.         case 'c':
  1167.             sprintf(s, "%s=%d \t#%s\015", k->name,
  1168.                 *((unsigned char *)k->valptr), k->description);
  1169.             break;
  1170.         case 'i':
  1171.             sprintf(s, "%s=%d \t#%s\015", k->name,
  1172.                 *((short *)k->valptr), k->description);
  1173.             break;
  1174.         case 'l':
  1175.             sprintf(s, "%s=\"%x", k->name, ((unsigned char *)k->valptr)[0]);
  1176.             m = strlen(s);
  1177.             if (k->size > 1) { 
  1178.                 for (i=1; i < k->size; i++) {
  1179.                     sprintf(s+m, " %x", ((unsigned char *)k->valptr)[i]);
  1180.                     m = strlen(s);
  1181.                     }
  1182.                 }
  1183.             sprintf(s+m, "\" \t#%s\015", k->description);
  1184.             break;
  1185.         case 'o':
  1186.             memcpy(crtemp, k->valptr, 4);
  1187.             crtemp[4] = 0;
  1188.             sprintf(s, "%s=\"%s\" \t#%s\015", k->name,
  1189.                     crtemp, k->description);
  1190.             break;
  1191.         case 'r':
  1192.             sprintf(s, "%s=\"%d", k->name, ((unsigned short *)k->valptr)[0]);
  1193.             m = strlen(s);
  1194.             if (k->size > 1) { 
  1195.                 for (i=1; i < k->size; i++) {
  1196.                     sprintf(s+m, " %d", ((unsigned short *)k->valptr)[i]);
  1197.                     m = strlen(s);
  1198.                     }
  1199.                 }
  1200.             sprintf(s+m, "\" \t#%s\015", k->description);
  1201.             break;
  1202.         case 'a':    /* arbitrary length string */
  1203.         case 's':    /* fixed-length string */
  1204.             if (k->type == 'a') {
  1205.                 strval = *((unsigned char **)k->valptr);
  1206.                 }
  1207.             else {
  1208.                 strval = (unsigned char *)k->valptr;
  1209.                 }
  1210.             if (strval[0] == 0) break;
  1211.             sprintf(s, "%s=\"", k->name);
  1212.             m = strlen(s);
  1213.             j = 0;
  1214.             while(strval[j] != 0) {
  1215.                 if (m > WRITEBUFFSIZE-2) {
  1216.                     count = m;
  1217.                     rc = FSWrite(fnum, &count, s);
  1218.                     if (rc != 0) {
  1219.                         stoperr(wsetalrt, cp);
  1220.                         writeok = 0;
  1221.                         break;
  1222.                         }
  1223.                     m = 0;
  1224.                     }
  1225.                 c = s[m++] = strval[j++];
  1226.                 if (c == '"') s[m++] = '"';
  1227.                 }
  1228.             if (!writeok) break;
  1229.             count = m;
  1230.             rc = FSWrite(fnum, &count, s);
  1231.             if (rc != 0) {
  1232.                 stoperr(wsetalrt, cp);
  1233.                 writeok = 0;
  1234.                 break;
  1235.                 }
  1236.             sprintf(s, "\" \t#%s\015", k->description);
  1237.             break;
  1238.         case 'u':
  1239.             sprintf(s, "%s=%d \t#%s\015", k->name,
  1240.                 *((unsigned short *)k->valptr), k->description);
  1241.             break;
  1242.         case 'x':
  1243.             sprintf(s, "%s=%x \t#%s\015", k->name,
  1244.                 *((unsigned char *)k->valptr), k->description);
  1245.             break;
  1246.         default:
  1247.             break;
  1248.         }
  1249.     if (!writeok) break;
  1250.     count = strlen(s);
  1251.     rc = 0;
  1252.     if (count > 0) {
  1253.         rc = FSWrite(fnum, &count, s);
  1254.         }
  1255.     if (rc != 0) {
  1256.         stoperr(wsetalrt, cp);
  1257.         break;
  1258.         }
  1259.     k++;
  1260.     }
  1261. rc = FSClose(fnum);
  1262. if (rc != 0) {
  1263.     stoperr(wsetalrt, cp);
  1264.     }
  1265. }
  1266.  
  1267. short new_settings(cnr *cp)
  1268. {
  1269. short savepth, saveptv, rc;
  1270.  
  1271. if (strcmp(cp->cshostname, cp->fshostname) != 0) return(1);
  1272. if (strcmp(cp->cskybdname, cp->fskybdname) != 0) return(1);
  1273. if (strcmp(cp->csnlname, cp->fsnlname) != 0) return(1);
  1274. if (strcmp(cp->cssndname, cp->fssndname) != 0) return(1);
  1275.                         /* compare all other settings, except window position */
  1276. savepth = cp->fs.windpth;
  1277. saveptv = cp->fs.windptv;
  1278. cp->fs.windpth = cp->cs.windpth;
  1279. cp->fs.windptv = cp->cs.windptv;
  1280. rc = (cp->fs != cp->cs);
  1281. cp->fs.windpth = savepth;
  1282. cp->fs.windptv = saveptv;
  1283. return(rc);
  1284. }
  1285.  
  1286. OSErr fsrdopen(unsigned char *fname, short vref, short *fref)
  1287. {                /* open file read-only */
  1288. IOParam pbi;
  1289. OSErr rc;
  1290.  
  1291. /* initialize parameter block */
  1292. memset(&pbi, 0, sizeof(IOParam));
  1293.  
  1294. pbi.ioNamePtr = (StringPtr)fname;
  1295. pbi.ioVRefNum = vref;
  1296. pbi.ioPermssn = fsRdPerm;
  1297. c2pstr(fname);
  1298. rc = PBOpen((ParmBlkPtr)&pbi, 0);
  1299. *fref = pbi.ioRefNum;
  1300. p2cstr(fname);
  1301. return(rc);
  1302. }
  1303.  
  1304. void copyconfig(settings_list *sl,            /* set session config. variables */
  1305.                 unsigned char *hostname,
  1306.                 unsigned char *wtitle)
  1307. {
  1308. cf_dblevel = sl->dblevel;
  1309. cf_setsflg = sl->setsflg;
  1310. cf_timeout = sl->timeout;
  1311. cf_retries = sl->retries;
  1312. cf_dfltptsize = sl->dfltptsize;
  1313. cf_altptsize = sl->altptsize;
  1314. cf_altrows = sl->altrows;
  1315. cf_altcols = sl->altcols;
  1316. cf_windmax = sl->windmax;
  1317. cf_custrows = sl->custrows;
  1318. cf_custcols = sl->custcols;
  1319. cf_savewpos = sl->savewpos;
  1320. cf_ext3270 = sl->ext3270;
  1321. cf_nographics = sl->nographics;
  1322. cf_nocolor = sl->nocolor;
  1323. strcpy(cf_hostname, hostname);
  1324. strcpy(cf_wtitle, wtitle);
  1325. }